home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / CodeWarrior Lite / Metrowerks C⁄C++ Lite / Headers / Universal Headers 2.0.1f / AppleTalk.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-22  |  37.7 KB  |  1,154 lines  |  [TEXT/MMCC]
  1. /*
  2.      File:        AppleTalk.h
  3.  
  4.      Contains:    AppleTalk Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. */
  19.  
  20. #ifndef __APPLETALK__
  21. #define __APPLETALK__
  22.  
  23.  
  24. #ifndef __TYPES__
  25. #include <Types.h>
  26. #endif
  27. /*    #include <ConditionalMacros.h>                                */
  28.  
  29. #ifndef __OSUTILS__
  30. #include <OSUtils.h>
  31. #endif
  32. /*    #include <MixedMode.h>                                        */
  33. /*    #include <Memory.h>                                            */
  34.  
  35. #ifdef __cplusplus
  36. extern "C" {
  37. #endif
  38.  
  39. #if PRAGMA_ALIGN_SUPPORTED
  40. #pragma options align=mac68k
  41. #endif
  42.  
  43. #if PRAGMA_IMPORT_SUPPORTED
  44. #pragma import on
  45. #endif
  46.  
  47.  
  48. enum {
  49. /* Driver unit and reference numbers (ADSP is dynamic) */
  50.     mppUnitNum                    = 9,                            /* MPP unit number */
  51.     atpUnitNum                    = 10,                            /* ATP unit number */
  52.     xppUnitNum                    = 40,                            /* XPP unit number */
  53.     mppRefNum                    = -10,                            /* MPP reference number */
  54.     atpRefNum                    = -11,                            /* ATP reference number */
  55.     xppRefNum                    = -41,                            /* XPP reference number */
  56. /* .MPP csCodes */
  57.     lookupReply                    = 242,                            /* This command queued to ourself */
  58.     writeLAP                    = 243,                            /* Write out LAP packet */
  59.     detachPH                    = 244,                            /* Detach LAP protocol handler */
  60.     attachPH                    = 245,                            /* Attach LAP protocol handler */
  61.     writeDDP                    = 246,                            /* Write out DDP packet */
  62.     closeSkt                    = 247,                            /* Close DDP socket */
  63.     openSkt                        = 248,                            /* Open DDP socket */
  64.     loadNBP                        = 249,                            /* Load NBP command-executing code */
  65.     lastResident                = 249,                            /* Last resident command */
  66.     confirmName                    = 250,                            /* Confirm name */
  67.     lookupName                    = 251,                            /* Look up name on internet */
  68.     removeName                    = 252,                            /* Remove name from Names Table */
  69.     registerName                = 253,                            /* Register name in Names Table */
  70.     killNBP                        = 254                            /* Kill outstanding NBP request */
  71. };
  72.  
  73. enum {
  74.     unloadNBP                    = 255,                            /* Unload NBP command code */
  75.     setSelfSend                    = 256,                            /* MPP: Set to allow writes to self */
  76.     SetMyZone                    = 257,                            /* Set my zone name */
  77.     GetATalkInfo                = 258,                            /* get AppleTalk information */
  78.     ATalkClosePrep                = 259,                            /* AppleTalk close query */
  79. /* .ATP csCodes */
  80.     nSendRequest                = 248,                            /* NSendRequest code */
  81.     relRspCB                    = 249,                            /* Release RspCB */
  82.     closeATPSkt                    = 250,                            /* Close ATP socket */
  83.     addResponse                    = 251,                            /* Add response code | Require open skt */
  84.     sendResponse                = 252,                            /* Send response code */
  85.     getRequest                    = 253,                            /* Get request code */
  86.     openATPSkt                    = 254,                            /* Open ATP socket */
  87.     sendRequest                    = 255,                            /* Send request code */
  88.     relTCB                        = 256,                            /* Release TCB */
  89.     killGetReq                    = 257,                            /* Kill GetRequest */
  90.     killSendReq                    = 258,                            /* Kill SendRequest */
  91.     killAllGetReq                = 259,                            /* Kill all getRequests for a skt */
  92. /* .XPP csCodes */
  93.     openSess                    = 255,                            /* Open session */
  94.     closeSess                    = 254,                            /* Close session */
  95.     userCommand                    = 253                            /* User command */
  96. };
  97.  
  98. enum {
  99.     userWrite                    = 252,                            /* User write */
  100.     getStatus                    = 251,                            /* Get status */
  101.     afpCall                        = 250,                            /* AFP command (buffer has command code) */
  102.     getParms                    = 249,                            /* Get parameters */
  103.     abortOS                        = 248,                            /* Abort open session request */
  104.     closeAll                    = 247,                            /* Close all open sessions */
  105.     xCall                        = 246,                            /* .XPP extended calls */
  106. /* Transition Queue transition types */
  107.     ATTransOpen                    = 0,                            /*AppleTalk has opened*/
  108.     ATTransClose                = 2,                            /*AppleTalk is about to close*/
  109.     ATTransClosePrep            = 3,                            /*Is it OK to close AppleTalk ?*/
  110.     ATTransCancelClose            = 4,                            /*Cancel the ClosePrep transition*/
  111.     afpByteRangeLock            = 1,                            /*AFPCall command codes*/
  112.     afpVolClose                    = 2,                            /*AFPCall command codes*/
  113.     afpDirClose                    = 3,                            /*AFPCall command codes*/
  114.     afpForkClose                = 4,                            /*AFPCall command codes*/
  115.     afpCopyFile                    = 5,                            /*AFPCall command codes*/
  116.     afpDirCreate                = 6,                            /*AFPCall command codes*/
  117.     afpFileCreate                = 7,                            /*AFPCall command codes*/
  118.     afpDelete                    = 8,                            /*AFPCall command codes*/
  119.     afpEnumerate                = 9                                /*AFPCall command codes*/
  120. };
  121.  
  122. enum {
  123.     afpFlush                    = 10,                            /*AFPCall command codes*/
  124.     afpForkFlush                = 11,                            /*AFPCall command codes*/
  125.     afpGetDirParms                = 12,                            /*AFPCall command codes*/
  126.     afpGetFileParms                = 13,                            /*AFPCall command codes*/
  127.     afpGetForkParms                = 14,                            /*AFPCall command codes*/
  128.     afpGetSInfo                    = 15,                            /*AFPCall command codes*/
  129.     afpGetSParms                = 16,                            /*AFPCall command codes*/
  130.     afpGetVolParms                = 17,                            /*AFPCall command codes*/
  131.     afpLogin                    = 18,                            /*AFPCall command codes*/
  132.     afpContLogin                = 19,                            /*AFPCall command codes*/
  133.     afpLogout                    = 20,                            /*AFPCall command codes*/
  134.     afpMapID                    = 21,                            /*AFPCall command codes*/
  135.     afpMapName                    = 22,                            /*AFPCall command codes*/
  136.     afpMove                        = 23,                            /*AFPCall command codes*/
  137.     afpOpenVol                    = 24,                            /*AFPCall command codes*/
  138.     afpOpenDir                    = 25,                            /*AFPCall command codes*/
  139.     afpOpenFork                    = 26,                            /*AFPCall command codes*/
  140.     afpRead                        = 27,                            /*AFPCall command codes*/
  141.     afpRename                    = 28,                            /*AFPCall command codes*/
  142.     afpSetDirParms                = 29                            /*AFPCall command codes*/
  143. };
  144.  
  145. enum {
  146.     afpSetFileParms                = 30,                            /*AFPCall command codes*/
  147.     afpSetForkParms                = 31,                            /*AFPCall command codes*/
  148.     afpSetVolParms                = 32,                            /*AFPCall command codes*/
  149.     afpWrite                    = 33,                            /*AFPCall command codes*/
  150.     afpGetFlDrParms                = 34,                            /*AFPCall command codes*/
  151.     afpSetFlDrParms                = 35,                            /*AFPCall command codes*/
  152.     afpDTOpen                    = 48,                            /*AFPCall command codes*/
  153.     afpDTClose                    = 49,                            /*AFPCall command codes*/
  154.     afpGetIcon                    = 51,                            /*AFPCall command codes*/
  155.     afpGtIcnInfo                = 52,                            /*AFPCall command codes*/
  156.     afpAddAPPL                    = 53,                            /*AFPCall command codes*/
  157.     afpRmvAPPL                    = 54,                            /*AFPCall command codes*/
  158.     afpGetAPPL                    = 55,                            /*AFPCall command codes*/
  159.     afpAddCmt                    = 56,                            /*AFPCall command codes*/
  160.     afpRmvCmt                    = 57,                            /*AFPCall command codes*/
  161.     afpGetCmt                    = 58,                            /*AFPCall command codes*/
  162.     afpAddIcon                    = 192,                            /*Special code for ASP Write commands*/
  163.     xppLoadedBit                = 5,                            /* XPP bit in PortBUse */
  164.     scbMemSize                    = 192,                            /* Size of memory for SCB */
  165.     xppFlagClr                    = 0                                /* Cs for AFPCommandBlock */
  166. };
  167.  
  168. enum {
  169.     xppFlagSet                    = 128,                            /* StartEndFlag & NewLineFlag fields. */
  170.     lapSize                        = 20,
  171.     ddpSize                        = 26,
  172.     nbpSize                        = 26,
  173.     atpSize                        = 56,
  174.     atpXOvalue                    = 32,                            /*ATP exactly-once bit */
  175.     atpEOMvalue                    = 16,                            /*ATP End-Of-Message bit */
  176.     atpSTSvalue                    = 8,                            /*ATP Send-Transmission-Status bit */
  177.     atpTIDValidvalue            = 2,                            /*ATP trans. ID valid bit */
  178.     atpSendChkvalue                = 1,                            /*ATP send checksum bit */
  179.     zipGetLocalZones            = 5,
  180.     zipGetZoneList                = 6,
  181.     zipGetMyZone                = 7,
  182.     LAPMgrPtr                    = 0xB18,                        /*Entry point for LAP Manager*/
  183.     LAPMgrCall                    = 2,                            /*Offset to LAP routines*/
  184.     LAddAEQ                        = 23,                            /*LAPAddATQ routine selector*/
  185.     LRmvAEQ                        = 24                            /*LAPRmvATQ routine selector*/
  186. };
  187.  
  188. #define MPPioCompletion MPP.ioCompletion
  189. #define MPPioResult MPP.ioResult
  190. #define MPPioRefNum MPP.ioRefNum
  191. #define MPPcsCode MPP.csCode
  192. #define LAPprotType LAP.protType
  193. #define LAPwdsPointer LAP.u.wdsPointer
  194. #define LAPhandler LAP.u.handler
  195. #define DDPsocket DDP.socket
  196. #define DDPchecksumFlag DDP.checksumFlag
  197. #define DDPwdsPointer DDP.u.wdsPointer
  198. #define DDPlistener DDP.u.listener
  199. #define NBPinterval NBP.interval
  200. #define NBPcount NBP.count
  201. #define NBPntQElPtr NBP.nbpPtrs.ntQElPtr
  202. #define NBPentityPtr NBP.nbpPtrs.entityPtr
  203. #define NBPverifyFlag NBP.parm.verifyFlag
  204. #define NBPretBuffPtr NBP.parm.Lookup.retBuffPtr
  205. #define NBPretBuffSize NBP.parm.Lookup.retBuffSize
  206. #define NBPmaxToGet NBP.parm.Lookup.maxToGet
  207. #define NBPnumGotten NBP.parm.Lookup.numGotten
  208. #define NBPconfirmAddr NBP.parm.Confirm.confirmAddr
  209. #define NBPnKillQEl NBPKILL.nKillQEl
  210. #define NBPnewSocket NBP.parm.Confirm.newSocket
  211. #define ATPioCompletion ATP.ioCompletion
  212. #define ATPioResult ATP.ioResult
  213. #define ATPuserData ATP.userData
  214. #define ATPreqTID ATP.reqTID
  215. #define ATPioRefNum ATP.ioRefNum
  216. #define ATPcsCode ATP.csCode
  217. #define ATPatpSocket ATP.atpSocket
  218. #define ATPatpFlags ATP.atpFlags
  219. #define ATPaddrBlock ATP.addrBlock
  220. #define ATPreqLength ATP.reqLength
  221. #define ATPreqPointer ATP.reqPointer
  222. #define ATPbdsPointer ATP.bdsPointer
  223. #define ATPtimeOutVal SREQ.timeOutVal
  224. #define ATPnumOfResps SREQ.numOfResps
  225. #define ATPretryCount SREQ.retryCount
  226. #define ATPnumOfBuffs OTH1.u.numOfBuffs
  227. #define ATPbitMap OTH1.u.bitMap
  228. #define ATPrspNum OTH1.u.rspNum
  229. #define ATPbdsSize OTH2.bdsSize
  230. #define ATPtransID OTH2.transID
  231. #define ATPaKillQEl KILL.aKillQEl
  232. enum {
  233.     tLAPRead,
  234.     tLAPWrite,
  235.     tDDPRead,
  236.     tDDPWrite,
  237.     tNBPLookup,
  238.     tNBPConfirm,
  239.     tNBPRegister,
  240.     tATPSndRequest,
  241.     tATPGetRequest,
  242.     tATPSdRsp,
  243.     tATPAddRsp,
  244.     tATPRequest,
  245.     tATPResponse
  246. };
  247.  
  248. typedef SInt8 ABCallType;
  249.  
  250.  
  251. enum {
  252.     lapProto,
  253.     ddpProto,
  254.     nbpProto,
  255.     atpProto
  256. };
  257.  
  258. typedef UInt8 ABProtoType;
  259.  
  260. typedef Byte ABByte;
  261.  
  262. struct LAPAdrBlock {
  263.     UInt8                            dstNodeID;
  264.     UInt8                            srcNodeID;
  265.     ABByte                            lapProtType;
  266.     UInt8                            filler;                        /*    Filler for proper byte alignment*/
  267. };
  268. typedef struct LAPAdrBlock LAPAdrBlock;
  269.  
  270. typedef struct ATQEntry ATQEntry, *ATQEntryPtr;
  271.  
  272. typedef long (*ATalkTransitionEventProcPtr)(long eventCode, ATQEntryPtr qElem, void *eventParameter);
  273.  
  274. #if GENERATINGCFM
  275. typedef UniversalProcPtr ATalkTransitionEventUPP;
  276. #else
  277. typedef ATalkTransitionEventProcPtr ATalkTransitionEventUPP;
  278. #endif
  279.  
  280. typedef ATalkTransitionEventUPP ATalkTransitionEvent;
  281.  
  282. struct ATQEntry {
  283.     ATQEntry                        *qLink;                        /*next queue entry*/
  284.     short                            qType;                        /*queue type*/
  285.     ATalkTransitionEventUPP            CallAddr;                    /*your routine descriptor*/
  286. };
  287. struct AddrBlock {
  288.     UInt16                            aNet;
  289.     UInt8                            aNode;
  290.     UInt8                            aSocket;
  291. };
  292. typedef struct AddrBlock AddrBlock;
  293.  
  294. /* Real definition of EntityName is 3 PACKED strings of any length (32 is just an example). No
  295. offests for Asm since each String address must be calculated by adding length byte to last string ptr.
  296. In Pascal, String(32) will be 34 bytes long since fields never start on an odd byte unless they are 
  297. only a byte long. So this will generate correct looking interfaces for Pascal and C, but they will not
  298. be the same, which is OK since they are not used. */
  299. struct EntityName {
  300.     Str32                            objStr;
  301.     SInt8                            pad1;                        /*Str32's aligned on even word boundries.*/
  302.     Str32                            typeStr;
  303.     SInt8                            pad2;
  304.     Str32                            zoneStr;
  305.     SInt8                            pad3;
  306. };
  307. typedef struct EntityName EntityName;
  308.  
  309. typedef EntityName *EntityPtr;
  310.  
  311. struct RetransType {
  312.     UInt8                            retransInterval;
  313.     UInt8                            retransCount;
  314. };
  315. typedef struct RetransType RetransType;
  316.  
  317. struct BDSElement {
  318.     short                            buffSize;
  319.     Ptr                                buffPtr;
  320.     short                            dataSize;
  321.     long                            userBytes;
  322. };
  323. typedef struct BDSElement BDSElement;
  324.  
  325. typedef BDSElement BDSType[8];
  326.  
  327. typedef BDSElement *BDSPtr;
  328.  
  329. typedef char BitMapType;
  330.  
  331. struct ATLAPRec {
  332.     ABCallType                        abOpcode;
  333.     SInt8                            filler;                        /*    Filler for proper byte alignment*/
  334.     short                            abResult;
  335.     long                            abUserReference;
  336.     LAPAdrBlock                        lapAddress;
  337.     short                            lapReqCount;
  338.     short                            lapActCount;
  339.     Ptr                                lapDataPtr;
  340. };
  341. typedef struct ATLAPRec ATLAPRec;
  342.  
  343. typedef ATLAPRec *ATLAPRecPtr, **ATLAPRecHandle;
  344.  
  345. struct ATDDPRec {
  346.     ABCallType                        abOpcode;
  347.     SInt8                            filler;                        /*    Filler for proper byte alignment*/
  348.     short                            abResult;
  349.     long                            abUserReference;
  350.     short                            ddpType;
  351.     short                            ddpSocket;
  352.     AddrBlock                        ddpAddress;
  353.     short                            ddpReqCount;
  354.     short                            ddpActCount;
  355.     Ptr                                ddpDataPtr;
  356.     short                            ddpNodeID;
  357. };
  358. typedef struct ATDDPRec ATDDPRec;
  359.  
  360. typedef ATDDPRec *ATDDPRecPtr, **ATDDPRecHandle;
  361.  
  362. struct ATNBPRec {
  363.     ABCallType                        abOpcode;
  364.     SInt8                            filler;                        /*    Filler for proper byte alignment*/
  365.     short                            abResult;
  366.     long                            abUserReference;
  367.     EntityPtr                        nbpEntityPtr;
  368.     Ptr                                nbpBufPtr;
  369.     short                            nbpBufSize;
  370.     short                            nbpDataField;
  371.     AddrBlock                        nbpAddress;
  372.     RetransType                        nbpRetransmitInfo;
  373. };
  374. typedef struct ATNBPRec ATNBPRec;
  375.  
  376. typedef ATNBPRec *ATNBPRecPtr, **ATNBPRecHandle;
  377.  
  378. struct ATATPRec {
  379.     ABCallType                        abOpcode;
  380.     SInt8                            filler1;                    /*    Filler for proper byte alignment*/
  381.     short                            abResult;
  382.     long                            abUserReference;
  383.     short                            atpSocket;
  384.     AddrBlock                        atpAddress;
  385.     short                            atpReqCount;
  386.     Ptr                                atpDataPtr;
  387.     BDSPtr                            atpRspBDSPtr;
  388.     BitMapType                        atpBitMap;
  389.     UInt8                            filler2;                    /*    Filler for proper byte alignment*/
  390.     short                            atpTransID;
  391.     short                            atpActCount;
  392.     long                            atpUserData;
  393.     Boolean                            atpXO;
  394.     Boolean                            atpEOM;
  395.     short                            atpTimeOut;
  396.     short                            atpRetries;
  397.     short                            atpNumBufs;
  398.     short                            atpNumRsp;
  399.     short                            atpBDSSize;
  400.     long                            atpRspUData;
  401.     Ptr                                atpRspBuf;
  402.     short                            atpRspSize;
  403. };
  404. typedef struct ATATPRec ATATPRec;
  405.  
  406. typedef ATATPRec *ATATPRecPtr, **ATATPRecHandle;
  407.  
  408. struct AFPCommandBlock {
  409.     UInt8                            cmdByte;
  410.     UInt8                            startEndFlag;
  411.     short                            forkRefNum;
  412.     long                            rwOffset;
  413.     long                            reqCount;
  414.     UInt8                            newLineFlag;
  415.     char                            newLineChar;
  416. };
  417. typedef struct AFPCommandBlock AFPCommandBlock;
  418.  
  419. typedef union MPPParamBlock MPPParamBlock, *MPPPBPtr;
  420.  
  421. typedef union ATPParamBlock ATPParamBlock, *ATPPBPtr;
  422.  
  423. typedef union XPPParamBlock XPPParamBlock, *XPPParmBlkPtr;
  424.  
  425. /*
  426.         MPPCompletionProcPtr uses register based parameters on the 68k and cannot
  427.         be written in or called from a high-level language without the help of
  428.         mixed mode or assembly glue.
  429.  
  430.             typedef pascal void (*MPPCompletionProcPtr)(MPPPBPtr thePBptr);
  431.  
  432.         In:
  433.          => thePBptr        A0.L
  434. */
  435. /*
  436.         ATPCompletionProcPtr uses register based parameters on the 68k and cannot
  437.         be written in or called from a high-level language without the help of
  438.         mixed mode or assembly glue.
  439.  
  440.             typedef pascal void (*ATPCompletionProcPtr)(ATPPBPtr thePBptr);
  441.  
  442.         In:
  443.          => thePBptr        A0.L
  444. */
  445. /*
  446.         XPPCompletionProcPtr uses register based parameters on the 68k and cannot
  447.         be written in or called from a high-level language without the help of
  448.         mixed mode or assembly glue.
  449.  
  450.             typedef pascal void (*XPPCompletionProcPtr)(XPPParmBlkPtr thePBptr);
  451.  
  452.         In:
  453.          => thePBptr        A0.L
  454. */
  455. /*
  456.         AttnRoutineProcPtr uses register based parameters on the 68k and cannot
  457.         be written in or called from a high-level language without the help of
  458.         mixed mode or assembly glue.
  459.  
  460.             typedef pascal void (*AttnRoutineProcPtr)(short sessRefnum, short attnBytes);
  461.  
  462.         In:
  463.          => sessRefnum      D0.W
  464.          => attnBytes       D1.W
  465. */
  466.  
  467. #if GENERATINGCFM
  468. typedef UniversalProcPtr MPPCompletionUPP;
  469. typedef UniversalProcPtr ATPCompletionUPP;
  470. typedef UniversalProcPtr XPPCompletionUPP;
  471. typedef UniversalProcPtr AttnRoutineUPP;
  472. #else
  473. typedef Register68kProcPtr MPPCompletionUPP;
  474. typedef Register68kProcPtr ATPCompletionUPP;
  475. typedef Register68kProcPtr XPPCompletionUPP;
  476. typedef Register68kProcPtr AttnRoutineUPP;
  477. #endif
  478.  
  479. struct WDSElement {
  480.     short                            entryLength;
  481.     Ptr                                entryPtr;
  482. };
  483. typedef struct WDSElement WDSElement;
  484.  
  485. struct NTElement {
  486.     AddrBlock                        nteAddress;                    /*network address of entity*/
  487.     SInt8                            filler;
  488.     SInt8                            entityData[99];                /*Object, Type & Zone*/
  489. };
  490. typedef struct NTElement NTElement;
  491.  
  492. struct NamesTableEntry {
  493.     Ptr                                qNext;                        /*ptr to next NTE*/
  494.     NTElement                        nt;
  495. };
  496. typedef struct NamesTableEntry NamesTableEntry;
  497.  
  498. #define XPPPBHeader             \
  499.     QElem *qLink;                \
  500.     short qType;                \
  501.     short ioTrap;                \
  502.     Ptr ioCmdAddr;                \
  503.     XPPCompletionUPP ioCompletion; \
  504.     OSErr ioResult;                \
  505.     long cmdResult;                \
  506.     short ioVRefNum;            \
  507.     short ioRefNum;                \
  508.     short csCode;
  509. typedef Boolean (*MPPProtocolHandlerProcPtr)(Ptr SCCAddr1, Ptr SCCAddr2, Ptr MPPLocalVars, Ptr nextFreeByteInRHA, Ptr ReadPacketAndReadRestPtr, short numBytesLeftToReadInPacket);
  510. typedef Boolean (*DDPSocketListenerProcPtr)(Ptr SCCAddr1, Ptr SCCAddr2, Ptr MPPLocalVars, Ptr nextFreeByteInRHA, Ptr ReadPacketAndReadRestPtr, UInt8 packetDestinationNumber, short numBytesLeftToReadInPacket);
  511.  
  512. #if GENERATINGCFM
  513. typedef UniversalProcPtr MPPProtocolHandlerUPP;
  514. typedef UniversalProcPtr DDPSocketListenerUPP;
  515. #else
  516. typedef Register68kProcPtr MPPProtocolHandlerUPP;
  517. typedef Register68kProcPtr DDPSocketListenerUPP;
  518. #endif
  519.  
  520. struct MPPparms {
  521.     QElem                            *qLink;
  522.     short                            qType;
  523.     short                            ioTrap;
  524.     Ptr                                ioCmdAddr;
  525.     ATPCompletionUPP                ioCompletion;
  526.     OSErr                            ioResult;
  527.     long                            userData;
  528.     short                            reqTID;
  529.     short                            ioRefNum;
  530.     short                            csCode;
  531. };
  532. typedef struct MPPparms MPPparms;
  533.  
  534. struct LAPparms {
  535.     QElem                            *qLink;
  536.     short                            qType;
  537.     short                            ioTrap;
  538.     Ptr                                ioCmdAddr;
  539.     ATPCompletionUPP                ioCompletion;
  540.     OSErr                            ioResult;
  541.     long                            userData;
  542.     short                            reqTID;
  543.     short                            ioRefNum;
  544.     short                            csCode;
  545.     UInt8                            protType;                    /*ALAP protocol Type */
  546.     UInt8                            filler;
  547.     union {
  548.         Ptr                                wdsPointer;                /*-> write data structure*/
  549.         MPPProtocolHandlerUPP            handler;                /*-> protocol handler routine*/
  550.     } u;
  551. };
  552.  
  553. typedef struct LAPparms LAPparms;
  554.  
  555. struct DDPparms {
  556.     QElem                            *qLink;
  557.     short                            qType;
  558.     short                            ioTrap;
  559.     Ptr                                ioCmdAddr;
  560.     ATPCompletionUPP                ioCompletion;
  561.     OSErr                            ioResult;
  562.     long                            userData;
  563.     short                            reqTID;
  564.     short                            ioRefNum;
  565.     short                            csCode;
  566.     UInt8                            socket;                        /*socket number */
  567.     UInt8                            checksumFlag;                /*check sum flag */
  568.     union {
  569.         Ptr                                wdsPointer;                /*-> write data structure*/
  570.         DDPSocketListenerUPP            listener;                /*->write data structure or -> Listener*/
  571.     } u;
  572. };
  573.  
  574. typedef struct DDPparms DDPparms;
  575.  
  576. union NBPPtrs {
  577.     Ptr                                ntQElPtr;
  578.     Ptr                                entityPtr;
  579. };
  580. typedef union NBPPtrs NBPPtrs;
  581.  
  582. union LookupConfirmParams {
  583.     UInt8                            verifyFlag;
  584.     struct {
  585.         Ptr                                retBuffPtr;
  586.         short                            retBuffSize;
  587.         short                            maxToGet;
  588.         short                            numGotten;
  589.     }                                Lookup;
  590.     struct {
  591.         AddrBlock                        confirmAddr;
  592.         UInt8                            newSocket;
  593.         UInt8                            filler;                    /*    Filler for proper byte alignment*/
  594.     }                                Confirm;
  595. };
  596. typedef union LookupConfirmParams LookupConfirmParams;
  597.  
  598. struct NBPparms {
  599.     QElem                            *qLink;
  600.     short                            qType;
  601.     short                            ioTrap;
  602.     Ptr                                ioCmdAddr;
  603.     ATPCompletionUPP                ioCompletion;
  604.     OSErr                            ioResult;
  605.     long                            userData;
  606.     short                            reqTID;
  607.     short                            ioRefNum;
  608.     short                            csCode;
  609.     UInt8                            interval;                    /*retry interval */
  610.     UInt8                            count;                        /*retry count */
  611.     NBPPtrs                            nbpPtrs;
  612.     LookupConfirmParams                parm;
  613. };
  614. typedef struct NBPparms NBPparms;
  615.  
  616. struct SetSelfparms {
  617.     QElem                            *qLink;
  618.     short                            qType;
  619.     short                            ioTrap;
  620.     Ptr                                ioCmdAddr;
  621.     ATPCompletionUPP                ioCompletion;
  622.     OSErr                            ioResult;
  623.     long                            userData;
  624.     short                            reqTID;
  625.     short                            ioRefNum;
  626.     short                            csCode;
  627.     UInt8                            newSelfFlag;                /*self-send toggle flag */
  628.     UInt8                            oldSelfFlag;                /*previous self-send state */
  629. };
  630. typedef struct SetSelfparms SetSelfparms;
  631.  
  632. struct NBPKillparms {
  633.     QElem                            *qLink;
  634.     short                            qType;
  635.     short                            ioTrap;
  636.     Ptr                                ioCmdAddr;
  637.     ATPCompletionUPP                ioCompletion;
  638.     OSErr                            ioResult;
  639.     long                            userData;
  640.     short                            reqTID;
  641.     short                            ioRefNum;
  642.     short                            csCode;
  643.     Ptr                                nKillQEl;                    /*ptr to i/o queue element to cancel */
  644. };
  645. typedef struct NBPKillparms NBPKillparms;
  646.  
  647. struct GetAppleTalkInfoParm {
  648.     QElem                            *qLink;
  649.     short                            qType;
  650.     short                            ioTrap;
  651.     Ptr                                ioCmdAddr;
  652.     ATPCompletionUPP                ioCompletion;
  653.     OSErr                            ioResult;
  654.     long                            userData;
  655.     short                            reqTID;
  656.     short                            ioRefNum;
  657.     short                            csCode;
  658.     short                            version;
  659.     Ptr                                varsPtr;
  660.     Ptr                                DCEPtr;
  661.     short                            portID;
  662.     long                            configuration;
  663.     short                            selfSend;
  664.     short                            netLo;
  665.     short                            netHi;
  666.     long                            ourAdd;
  667.     long                            routerAddr;
  668.     short                            numOfPHs;
  669.     short                            numOfSkts;
  670.     short                            numNBPEs;
  671.     Ptr                                nTQueue;
  672.     short                            LAlength;
  673.     Ptr                                linkAddr;
  674.     Ptr                                zoneName;
  675. };
  676. typedef struct GetAppleTalkInfoParm GetAppleTalkInfoParm;
  677.  
  678. struct ATalkClosePrepParm {
  679.     QElem                            *qLink;
  680.     short                            qType;
  681.     short                            ioTrap;
  682.     Ptr                                ioCmdAddr;
  683.     ATPCompletionUPP                ioCompletion;
  684.     OSErr                            ioResult;
  685.     long                            userData;
  686.     short                            reqTID;
  687.     short                            ioRefNum;
  688.     short                            csCode;
  689.     Ptr                                appName;                    /*pointer to application name in buffer*/
  690. };
  691. typedef struct ATalkClosePrepParm ATalkClosePrepParm;
  692.  
  693. union MPPParamBlock {
  694.     MPPparms                        MPP;                        /*General MPP parms*/
  695.     LAPparms                        LAP;                        /*ALAP calls*/
  696.     DDPparms                        DDP;                        /*DDP calls*/
  697.     NBPparms                        NBP;                        /*NBP calls*/
  698.     SetSelfparms                    SETSELF;
  699.     NBPKillparms                    NBPKILL;
  700.     GetAppleTalkInfoParm            GAIINFO;
  701.     ATalkClosePrepParm                ATALKCLOSE;
  702. };
  703. struct XPPPrmBlk {
  704.     QElem                            *qLink;
  705.     short                            qType;
  706.     short                            ioTrap;
  707.     Ptr                                ioCmdAddr;
  708.     XPPCompletionUPP                ioCompletion;
  709.     OSErr                            ioResult;
  710.     long                            cmdResult;
  711.     short                            ioVRefNum;
  712.     short                            ioRefNum;
  713.     short                            csCode;
  714.     short                            sessRefnum;
  715.     UInt8                            aspTimeout;
  716.     UInt8                            aspRetry;
  717.     short                            cbSize;
  718.     Ptr                                cbPtr;
  719.     short                            rbSize;
  720.     Ptr                                rbPtr;
  721.     short                            wdSize;
  722.     Ptr                                wdPtr;
  723.     UInt8                            ccbStart[296];
  724. };
  725. typedef struct XPPPrmBlk XPPPrmBlk;
  726.  
  727. struct ASPGetparmsBlk {
  728.     QElem                            *qLink;
  729.     short                            qType;
  730.     short                            ioTrap;
  731.     Ptr                                ioCmdAddr;
  732.     XPPCompletionUPP                ioCompletion;
  733.     OSErr                            ioResult;
  734.     long                            cmdResult;
  735.     short                            ioVRefNum;
  736.     short                            ioRefNum;
  737.     short                            csCode;
  738.     short                            aspMaxCmdSize;
  739.     short                            aspQuantumSize;
  740.     short                            numSesss;
  741. };
  742. typedef struct ASPGetparmsBlk ASPGetparmsBlk;
  743.  
  744. struct ASPAbortPrm {
  745.     QElem                            *qLink;
  746.     short                            qType;
  747.     short                            ioTrap;
  748.     Ptr                                ioCmdAddr;
  749.     XPPCompletionUPP                ioCompletion;
  750.     OSErr                            ioResult;
  751.     long                            cmdResult;
  752.     short                            ioVRefNum;
  753.     short                            ioRefNum;
  754.     short                            csCode;
  755.     Ptr                                abortSCBPtr;                /*SCB pointer for AbortOS */
  756. };
  757. typedef struct ASPAbortPrm ASPAbortPrm;
  758.  
  759. struct ASPOpenPrm {
  760.     QElem                            *qLink;
  761.     short                            qType;
  762.     short                            ioTrap;
  763.     Ptr                                ioCmdAddr;
  764.     XPPCompletionUPP                ioCompletion;
  765.     OSErr                            ioResult;
  766.     long                            cmdResult;
  767.     short                            ioVRefNum;
  768.     short                            ioRefNum;
  769.     short                            csCode;
  770.     short                            sessRefnum;
  771.     UInt8                            aspTimeout;
  772.     UInt8                            aspRetry;
  773.     AddrBlock                        serverAddr;
  774.     Ptr                                scbPointer;
  775.     AttnRoutineUPP                    attnRoutine;
  776. };
  777. typedef struct ASPOpenPrm ASPOpenPrm, *ASPOpenPrmPtr;
  778.  
  779. struct AFPLoginPrm {
  780.     QElem                            *qLink;
  781.     short                            qType;
  782.     short                            ioTrap;
  783.     Ptr                                ioCmdAddr;
  784.     XPPCompletionUPP                ioCompletion;
  785.     OSErr                            ioResult;
  786.     long                            cmdResult;
  787.     short                            ioVRefNum;
  788.     short                            ioRefNum;
  789.     short                            csCode;
  790.     short                            sessRefnum;
  791.     UInt8                            aspTimeout;
  792.     UInt8                            aspRetry;
  793.     short                            cbSize;
  794.     Ptr                                cbPtr;
  795.     short                            rbSize;
  796.     Ptr                                rbPtr;
  797.     AddrBlock                        afpAddrBlock;
  798.     Ptr                                afpSCBPtr;
  799.     Ptr                                afpAttnRoutine;
  800.     UInt8                            ccbFill[144];                /*CCB memory allocated for driver  Login needs only 150 bytes BUT CCB really starts in the middle of AFPSCBPtr and also clobbers AFPAttnRoutine. */
  801. };
  802. typedef struct AFPLoginPrm AFPLoginPrm;
  803.  
  804. struct XCallParam {
  805.     QElem                            *qLink;
  806.     short                            qType;
  807.     short                            ioTrap;
  808.     Ptr                                ioCmdAddr;
  809.     XPPCompletionUPP                ioCompletion;
  810.     OSErr                            ioResult;
  811.     long                            cmdResult;
  812.     short                            ioVRefNum;
  813.     short                            ioRefNum;
  814.     short                            csCode;
  815.     short                            xppSubCode;
  816.     UInt8                            xppTimeout;
  817.     UInt8                            xppRetry;
  818.     short                            filler1;
  819.     Ptr                                zipBuffPtr;
  820.     short                            zipNumZones;
  821.     UInt8                            zipLastFlag;
  822.     UInt8                            filler2;
  823.     UInt8                            zipInfoField[70];
  824. };
  825. typedef struct XCallParam XCallParam;
  826.  
  827. union XPPParamBlock {
  828.     XPPPrmBlk                        XPP;
  829.     ASPGetparmsBlk                    GETPARM;
  830.     ASPAbortPrm                        ABORT;
  831.     ASPOpenPrm                        OPEN;
  832.     AFPLoginPrm                        LOGIN;
  833.     XCallParam                        XCALL;
  834. };
  835. #define MOREATPHeader             \
  836.     UInt8 atpSocket;                \
  837.     UInt8 atpFlags;                \
  838.     AddrBlock addrBlock;            \
  839.     short reqLength;                \
  840.     Ptr reqPointer;                \
  841.     Ptr bdsPointer;
  842. struct ATPparms {
  843.     QElem                            *qLink;
  844.     short                            qType;
  845.     short                            ioTrap;
  846.     Ptr                                ioCmdAddr;
  847.     ATPCompletionUPP                ioCompletion;
  848.     OSErr                            ioResult;
  849.     long                            userData;
  850.     short                            reqTID;
  851.     short                            ioRefNum;
  852.     short                            csCode;
  853.     UInt8                            atpSocket;
  854.     UInt8                            atpFlags;
  855.     AddrBlock                        addrBlock;
  856.     short                            reqLength;
  857.     Ptr                                reqPointer;
  858.     Ptr                                bdsPointer;
  859. };
  860. typedef struct ATPparms ATPparms;
  861.  
  862. struct SendReqparms {
  863.     QElem                            *qLink;
  864.     short                            qType;
  865.     short                            ioTrap;
  866.     Ptr                                ioCmdAddr;
  867.     ATPCompletionUPP                ioCompletion;
  868.     OSErr                            ioResult;
  869.     long                            userData;
  870.     short                            reqTID;
  871.     short                            ioRefNum;
  872.     short                            csCode;
  873.     UInt8                            atpSocket;
  874.     UInt8                            atpFlags;
  875.     AddrBlock                        addrBlock;
  876.     short                            reqLength;
  877.     Ptr                                reqPointer;
  878.     Ptr                                bdsPointer;
  879.     UInt8                            numOfBuffs;
  880.     UInt8                            timeOutVal;
  881.     UInt8                            numOfResps;
  882.     UInt8                            retryCount;
  883.     short                            intBuff;
  884.     UInt8                            TRelTime;
  885.     SInt8                            filler0;
  886. };
  887. typedef struct SendReqparms SendReqparms;
  888.  
  889. struct ATPmisc1 {
  890.     QElem                            *qLink;
  891.     short                            qType;
  892.     short                            ioTrap;
  893.     Ptr                                ioCmdAddr;
  894.     ATPCompletionUPP                ioCompletion;
  895.     OSErr                            ioResult;
  896.     long                            userData;
  897.     short                            reqTID;
  898.     short                            ioRefNum;
  899.     short                            csCode;
  900.     UInt8                            atpSocket;
  901.     UInt8                            atpFlags;
  902.     AddrBlock                        addrBlock;
  903.     short                            reqLength;
  904.     Ptr                                reqPointer;
  905.     Ptr                                bdsPointer;
  906.     union {
  907.         UInt8                            bitMap;                    /*bitmap received */
  908.         UInt8                            numOfBuffs;                /*number of responses being sent*/
  909.         UInt8                            rspNum;                    /*sequence number*/
  910.     } u;
  911. };
  912.  
  913. typedef struct ATPmisc1 ATPmisc1;
  914.  
  915. struct ATPmisc2 {
  916.     QElem                            *qLink;
  917.     short                            qType;
  918.     short                            ioTrap;
  919.     Ptr                                ioCmdAddr;
  920.     ATPCompletionUPP                ioCompletion;
  921.     OSErr                            ioResult;
  922.     long                            userData;
  923.     short                            reqTID;
  924.     short                            ioRefNum;
  925.     short                            csCode;
  926.     UInt8                            atpSocket;
  927.     UInt8                            atpFlags;
  928.     AddrBlock                        addrBlock;
  929.     short                            reqLength;
  930.     Ptr                                reqPointer;
  931.     Ptr                                bdsPointer;
  932.     UInt8                            filler;
  933.     UInt8                            bdsSize;
  934.     short                            transID;
  935. };
  936. typedef struct ATPmisc2 ATPmisc2;
  937.  
  938. struct Killparms {
  939.     QElem                            *qLink;
  940.     short                            qType;
  941.     short                            ioTrap;
  942.     Ptr                                ioCmdAddr;
  943.     ATPCompletionUPP                ioCompletion;
  944.     OSErr                            ioResult;
  945.     long                            userData;
  946.     short                            reqTID;
  947.     short                            ioRefNum;
  948.     short                            csCode;
  949.     UInt8                            atpSocket;
  950.     UInt8                            atpFlags;
  951.     AddrBlock                        addrBlock;
  952.     short                            reqLength;
  953.     Ptr                                reqPointer;
  954.     Ptr                                bdsPointer;
  955.     Ptr                                aKillQEl;
  956. };
  957. typedef struct Killparms Killparms;
  958.  
  959. union ATPParamBlock {
  960.     ATPparms                        ATP;                        /*General ATP parms*/
  961.     SendReqparms                    SREQ;                        /*sendrequest parms*/
  962.     ATPmisc1                        OTH1;                        /*and a few others*/
  963.     ATPmisc2                        OTH2;                        /*and a few others*/
  964.     Killparms                        KILL;                        /*and a few others*/
  965. };
  966.  
  967. #if GENERATINGCFM
  968. #else
  969. #endif
  970.  
  971. enum {
  972.     uppATalkTransitionEventProcInfo = kCStackBased
  973.          | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  974.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(long)))
  975.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ATQEntryPtr)))
  976.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*))),
  977.     uppMPPCompletionProcInfo = kRegisterBased
  978.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterA0, SIZE_CODE(sizeof(MPPPBPtr))),
  979.     uppATPCompletionProcInfo = kRegisterBased
  980.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterA0, SIZE_CODE(sizeof(ATPPBPtr))),
  981.     uppXPPCompletionProcInfo = kRegisterBased
  982.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterA0, SIZE_CODE(sizeof(XPPParmBlkPtr))),
  983.     uppAttnRoutineProcInfo = kRegisterBased
  984.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterD0, SIZE_CODE(sizeof(short)))
  985.          | REGISTER_ROUTINE_PARAMETER(2, kRegisterD1, SIZE_CODE(sizeof(short))),
  986.     uppMPPProtocolHandlerProcInfo = SPECIAL_CASE_PROCINFO( kSpecialCaseProtocolHandler ),
  987.     uppDDPSocketListenerProcInfo = SPECIAL_CASE_PROCINFO( kSpecialCaseSocketListener )
  988. };
  989.  
  990. #if GENERATINGCFM
  991. #define NewATalkTransitionEventProc(userRoutine)        \
  992.         (ATalkTransitionEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppATalkTransitionEventProcInfo, GetCurrentArchitecture())
  993. #define NewMPPCompletionProc(userRoutine)        \
  994.         (MPPCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppMPPCompletionProcInfo, GetCurrentArchitecture())
  995. #define NewATPCompletionProc(userRoutine)        \
  996.         (ATPCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppATPCompletionProcInfo, GetCurrentArchitecture())
  997. #define NewXPPCompletionProc(userRoutine)        \
  998.         (XPPCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppXPPCompletionProcInfo, GetCurrentArchitecture())
  999. #define NewAttnRoutineProc(userRoutine)        \
  1000.         (AttnRoutineUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppAttnRoutineProcInfo, GetCurrentArchitecture())
  1001. #define NewMPPProtocolHandlerProc(userRoutine)        \
  1002.         (MPPProtocolHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppMPPProtocolHandlerProcInfo, GetCurrentArchitecture())
  1003. #define NewDDPSocketListenerProc(userRoutine)        \
  1004.         (DDPSocketListenerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDDPSocketListenerProcInfo, GetCurrentArchitecture())
  1005. #else
  1006. #define NewATalkTransitionEventProc(userRoutine)        \
  1007.         ((ATalkTransitionEventUPP) (userRoutine))
  1008. #define NewMPPCompletionProc(userRoutine)        \
  1009.         ((MPPCompletionUPP) (userRoutine))
  1010. #define NewATPCompletionProc(userRoutine)        \
  1011.         ((ATPCompletionUPP) (userRoutine))
  1012. #define NewXPPCompletionProc(userRoutine)        \
  1013.         ((XPPCompletionUPP) (userRoutine))
  1014. #define NewAttnRoutineProc(userRoutine)        \
  1015.         ((AttnRoutineUPP) (userRoutine))
  1016. #define NewMPPProtocolHandlerProc(userRoutine)        \
  1017.         ((MPPProtocolHandlerUPP) (userRoutine))
  1018. #define NewDDPSocketListenerProc(userRoutine)        \
  1019.         ((DDPSocketListenerUPP) (userRoutine))
  1020. #endif
  1021.  
  1022. #if GENERATINGCFM
  1023. #define CallATalkTransitionEventProc(userRoutine, eventCode, qElem, eventParameter)        \
  1024.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppATalkTransitionEventProcInfo, (eventCode), (qElem), (eventParameter))
  1025. #define CallMPPCompletionProc(userRoutine, thePBptr)        \
  1026.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppMPPCompletionProcInfo, (thePBptr))
  1027. #define CallATPCompletionProc(userRoutine, thePBptr)        \
  1028.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppATPCompletionProcInfo, (thePBptr))
  1029. #define CallXPPCompletionProc(userRoutine, thePBptr)        \
  1030.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppXPPCompletionProcInfo, (thePBptr))
  1031. #define CallAttnRoutineProc(userRoutine, sessRefnum, attnBytes)        \
  1032.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppAttnRoutineProcInfo, (sessRefnum), (attnBytes))
  1033. #define CallMPPProtocolHandlerProc(userRoutine, SCCAddr1, SCCAddr2, MPPLocalVars, nextFreeByteInRHA, ReadPacketAndReadRestPtr, numBytesLeftToReadInPacket)        \
  1034.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppMPPProtocolHandlerProcInfo, (SCCAddr1), (SCCAddr2), (MPPLocalVars), (nextFreeByteInRHA), (ReadPacketAndReadRestPtr), (numBytesLeftToReadInPacket))
  1035. #define CallDDPSocketListenerProc(userRoutine, SCCAddr1, SCCAddr2, MPPLocalVars, nextFreeByteInRHA, ReadPacketAndReadRestPtr, packetDestinationNumber, numBytesLeftToReadInPacket)        \
  1036.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDDPSocketListenerProcInfo, (SCCAddr1), (SCCAddr2), (MPPLocalVars), (nextFreeByteInRHA), (ReadPacketAndReadRestPtr), (packetDestinationNumber), (numBytesLeftToReadInPacket))
  1037. #else
  1038. #define CallATalkTransitionEventProc(userRoutine, eventCode, qElem, eventParameter)        \
  1039.         (*(userRoutine))((eventCode), (qElem), (eventParameter))
  1040. /* (*MPPCompletionProcPtr) cannot be called from a high-level language without the Mixed Mode Manager */
  1041. /* (*ATPCompletionProcPtr) cannot be called from a high-level language without the Mixed Mode Manager */
  1042. /* (*XPPCompletionProcPtr) cannot be called from a high-level language without the Mixed Mode Manager */
  1043. /* (*AttnRoutineProcPtr) cannot be called from a high-level language without the Mixed Mode Manager */
  1044. /* (*MPPProtocolHandlerProcPtr) cannot be called from a high-level language without the Mixed Mode Manager */
  1045. /* (*DDPSocketListenerProcPtr) cannot be called from a high-level language without the Mixed Mode Manager */
  1046. #endif
  1047.  
  1048. extern pascal OSErr OpenXPP(short *xppRefnum);
  1049. extern pascal OSErr ASPOpenSession(XPPParmBlkPtr thePBptr, Boolean async);
  1050. extern pascal OSErr ASPCloseSession(XPPParmBlkPtr thePBptr, Boolean async);
  1051. extern pascal OSErr ASPAbortOS(XPPParmBlkPtr thePBptr, Boolean async);
  1052. extern pascal OSErr ASPGetParms(XPPParmBlkPtr thePBptr, Boolean async);
  1053. extern pascal OSErr ASPCloseAll(XPPParmBlkPtr thePBptr, Boolean async);
  1054. extern pascal OSErr ASPUserWrite(XPPParmBlkPtr thePBptr, Boolean async);
  1055. extern pascal OSErr ASPUserCommand(XPPParmBlkPtr thePBptr, Boolean async);
  1056. extern pascal OSErr ASPGetStatus(XPPParmBlkPtr thePBptr, Boolean async);
  1057. #define ASPGetStatusSync(paramBlock) ASPGetStatus((paramBlock), FALSE)
  1058. extern pascal OSErr AFPCommand(XPPParmBlkPtr thePBptr, Boolean async);
  1059. extern pascal OSErr GetLocalZones(XPPParmBlkPtr thePBptr, Boolean async);
  1060. extern pascal OSErr GetZoneList(XPPParmBlkPtr thePBptr, Boolean async);
  1061. extern pascal OSErr GetMyZone(XPPParmBlkPtr thePBptr, Boolean async);
  1062. extern pascal OSErr PAttachPH(MPPPBPtr thePBptr, Boolean async);
  1063. extern pascal OSErr PDetachPH(MPPPBPtr thePBptr, Boolean async);
  1064. extern pascal OSErr PWriteLAP(MPPPBPtr thePBptr, Boolean async);
  1065. extern pascal OSErr POpenSkt(MPPPBPtr thePBptr, Boolean async);
  1066. extern pascal OSErr PCloseSkt(MPPPBPtr thePBptr, Boolean async);
  1067. extern pascal OSErr PWriteDDP(MPPPBPtr thePBptr, Boolean async);
  1068. extern pascal OSErr PRegisterName(MPPPBPtr thePBptr, Boolean async);
  1069. extern pascal OSErr PLookupName(MPPPBPtr thePBptr, Boolean async);
  1070. #define PLookupNameSync(paramBlock) PLookupName((paramBlock), FALSE)
  1071. extern pascal OSErr PConfirmName(MPPPBPtr thePBptr, Boolean async);
  1072. extern pascal OSErr PRemoveName(MPPPBPtr thePBptr, Boolean async);
  1073. extern pascal OSErr PSetSelfSend(MPPPBPtr thePBptr, Boolean async);
  1074. extern pascal OSErr PKillNBP(MPPPBPtr thePBptr, Boolean async);
  1075. extern pascal OSErr PGetAppleTalkInfo(MPPPBPtr thePBptr, Boolean async);
  1076. extern pascal OSErr PATalkClosePrep(MPPPBPtr thePBptr, Boolean async);
  1077. extern pascal OSErr POpenATPSkt(ATPPBPtr thePBptr, Boolean async);
  1078. extern pascal OSErr PCloseATPSkt(ATPPBPtr thePBPtr, Boolean async);
  1079. extern pascal OSErr PSendRequest(ATPPBPtr thePBPtr, Boolean async);
  1080. extern pascal OSErr PGetRequest(ATPPBPtr thePBPtr, Boolean async);
  1081. extern pascal OSErr PSendResponse(ATPPBPtr thePBPtr, Boolean async);
  1082. extern pascal OSErr PAddResponse(ATPPBPtr thePBPtr, Boolean async);
  1083. extern pascal OSErr PRelTCB(ATPPBPtr thePBPtr, Boolean async);
  1084. extern pascal OSErr PRelRspCB(ATPPBPtr thePBPtr, Boolean async);
  1085. extern pascal OSErr PNSendRequest(ATPPBPtr thePBPtr, Boolean async);
  1086. extern pascal OSErr PKillSendReq(ATPPBPtr thePBPtr, Boolean async);
  1087. extern pascal OSErr PKillGetReq(ATPPBPtr thePBPtr, Boolean async);
  1088. extern pascal OSErr ATPKillAllGetReq(ATPPBPtr thePBPtr, Boolean async);
  1089. extern pascal void BuildLAPwds(Ptr wdsPtr, Ptr dataPtr, short destHost, short prototype, short frameLen);
  1090. extern pascal void BuildDDPwds(Ptr wdsPtr, Ptr headerPtr, Ptr dataPtr, AddrBlock netAddr, short ddpType, short dataLen);
  1091. extern pascal void NBPSetEntity(Ptr buffer, ConstStr32Param nbpObject, ConstStr32Param nbpType, ConstStr32Param nbpZone);
  1092. extern pascal void NBPSetNTE(Ptr ntePtr, ConstStr32Param nbpObject, ConstStr32Param nbpType, ConstStr32Param nbpZone, short socket);
  1093. extern pascal short GetBridgeAddress(void);
  1094. extern pascal short BuildBDS(Ptr buffPtr, Ptr bdsPtr, short buffSize);
  1095. extern pascal OSErr MPPOpen(void);
  1096. extern pascal OSErr LAPAddATQ(ATQEntryPtr theATQEntry);
  1097. extern pascal OSErr LAPRmvATQ(ATQEntryPtr theATQEntry);
  1098. extern pascal OSErr ATPLoad(void);
  1099. extern pascal OSErr ATPUnload(void);
  1100. extern pascal OSErr NBPExtract(Ptr theBuffer, short numInBuf, short whichOne, EntityName *abEntity, AddrBlock *address);
  1101. extern pascal OSErr GetNodeAddress(short *myNode, short *myNet);
  1102. extern pascal Boolean IsMPPOpen(void);
  1103. extern pascal Boolean IsATPOpen(void);
  1104. extern pascal void ATEvent(long event, Ptr infoPtr);
  1105. extern pascal OSErr ATPreFlightEvent(long event, long cancel, Ptr infoPtr);
  1106. /*
  1107.     The following routines are obsolete and will not be supported on
  1108.     PowerPC. Equivalent functionality is provided by the routines
  1109.     above.
  1110. */
  1111. #if OLDROUTINENAMES && !GENERATINGCFM
  1112. extern pascal OSErr MPPClose(void);
  1113. extern pascal OSErr LAPOpenProtocol(ABByte theLAPType, Ptr protoPtr);
  1114. extern pascal OSErr LAPCloseProtocol(ABByte theLAPType);
  1115. extern pascal OSErr LAPWrite(ATLAPRecHandle abRecord, Boolean async);
  1116. extern pascal OSErr LAPRead(ATLAPRecHandle abRecord, Boolean async);
  1117. extern pascal OSErr LAPRdCancel(ATLAPRecHandle abRecord);
  1118. extern pascal OSErr DDPOpenSocket(short *theSocket, Ptr sktListener);
  1119. extern pascal OSErr DDPCloseSocket(short theSocket);
  1120. extern pascal OSErr DDPRead(ATDDPRecHandle abRecord, Boolean retCksumErrs, Boolean async);
  1121. extern pascal OSErr DDPWrite(ATDDPRecHandle abRecord, Boolean doChecksum, Boolean async);
  1122. extern pascal OSErr DDPRdCancel(ATDDPRecHandle abRecord);
  1123. extern pascal OSErr ATPOpenSocket(AddrBlock addrRcvd, short *atpSocket);
  1124. extern pascal OSErr ATPCloseSocket(short atpSocket);
  1125. extern pascal OSErr ATPSndRequest(ATATPRecHandle abRecord, Boolean async);
  1126. extern pascal OSErr ATPRequest(ATATPRecHandle abRecord, Boolean async);
  1127. extern pascal OSErr ATPReqCancel(ATATPRecHandle abRecord, Boolean async);
  1128. extern pascal OSErr ATPGetRequest(ATATPRecHandle abRecord, Boolean async);
  1129. extern pascal OSErr ATPSndRsp(ATATPRecHandle abRecord, Boolean async);
  1130. extern pascal OSErr ATPAddRsp(ATATPRecHandle abRecord);
  1131. extern pascal OSErr ATPResponse(ATATPRecHandle abRecord, Boolean async);
  1132. extern pascal OSErr ATPRspCancel(ATATPRecHandle abRecord, Boolean async);
  1133. extern pascal OSErr NBPRegister(ATNBPRecHandle abRecord, Boolean async);
  1134. extern pascal OSErr NBPLookup(ATNBPRecHandle abRecord, Boolean async);
  1135. extern pascal OSErr NBPConfirm(ATNBPRecHandle abRecord, Boolean async);
  1136. extern pascal OSErr NBPRemove(EntityPtr abEntity);
  1137. extern pascal OSErr NBPLoad(void);
  1138. extern pascal OSErr NBPUnload(void);
  1139. #endif
  1140.  
  1141. #if PRAGMA_IMPORT_SUPPORTED
  1142. #pragma import off
  1143. #endif
  1144.  
  1145. #if PRAGMA_ALIGN_SUPPORTED
  1146. #pragma options align=reset
  1147. #endif
  1148.  
  1149. #ifdef __cplusplus
  1150. }
  1151. #endif
  1152.  
  1153. #endif /* __APPLETALK__ */
  1154.